home *** CD-ROM | disk | FTP | other *** search
/ Champak 125 / Vol 125 (Damaged).iso / games / super_ju.swf / scripts / DefineButton2_66 / BUTTONCONDACTION on(keyPress Space).as
Encoding:
Text File  |  2008-11-13  |  80.3 KB  |  1,809 lines

  1. on(keyPress "<Space>"){
  2.    var ┬º\x01┬º = 216;
  3.    loop0:
  4.    while(true)
  5.    {
  6.       if(eval("\x01") == 216)
  7.       {
  8.          set("\x01",eval("\x01") + 143);
  9.          ┬º┬ºpush(true);
  10.          continue;
  11.       }
  12.       if(eval("\x01") == 656)
  13.       {
  14.          set("\x01",eval("\x01") + 276);
  15.          if(┬º┬ºpop())
  16.          {
  17.             set("\x01",eval("\x01") - 914);
  18.          }
  19.          continue;
  20.       }
  21.       if(eval("\x01") == 318)
  22.       {
  23.          set("\x01",eval("\x01") + 338);
  24.          ┬º┬ºpush(true);
  25.          continue;
  26.       }
  27.       if(eval("\x01") == 359)
  28.       {
  29.          set("\x01",eval("\x01") - 136);
  30.          if(┬º┬ºpop())
  31.          {
  32.             set("\x01",eval("\x01") + 392);
  33.          }
  34.          continue;
  35.       }
  36.       if(eval("\x01") == 279)
  37.       {
  38.          set("\x01",eval("\x01") + 39);
  39.          continue;
  40.       }
  41.       if(eval("\x01") == 18)
  42.       {
  43.          set("\x01",eval("\x01") + 291);
  44.          continue;
  45.       }
  46.       if(eval("\x01") == 145)
  47.       {
  48.          set("\x01",eval("\x01") + 615);
  49.          if(┬º┬ºpop())
  50.          {
  51.             set("\x01",eval("\x01") + 81);
  52.          }
  53.          continue;
  54.       }
  55.       if(eval("\x01") == 717)
  56.       {
  57.          set("\x01",eval("\x01") - 572);
  58.          ┬º┬ºpush(true);
  59.          continue;
  60.       }
  61.       if(eval("\x01") == 454)
  62.       {
  63.          set("\x01",eval("\x01") - 308);
  64.          if(┬º┬ºpop())
  65.          {
  66.             set("\x01",eval("\x01") + 815);
  67.          }
  68.          continue;
  69.       }
  70.       if(eval("\x01") == 146)
  71.       {
  72.          set("\x01",eval("\x01") + 815);
  73.          return getProperty(┬º┬ºpop(), _X);
  74.       }
  75.       if(eval("\x01") == 839)
  76.       {
  77.          set("\x01",eval("\x01") - 122);
  78.          continue;
  79.       }
  80.       if(eval("\x01") == 924)
  81.       {
  82.          set("\x01",eval("\x01") - 647);
  83.          if(┬º┬ºpop())
  84.          {
  85.             set("\x01",eval("\x01") - 105);
  86.          }
  87.          continue;
  88.       }
  89.       if(eval("\x01") == 518)
  90.       {
  91.          set("\x01",eval("\x01") - 200);
  92.          continue;
  93.       }
  94.       if(eval("\x01") == 713)
  95.       {
  96.          set("\x01",eval("\x01") - 438);
  97.          if(┬º┬ºpop())
  98.          {
  99.             set("\x01",eval("\x01") + 716);
  100.          }
  101.          continue;
  102.       }
  103.       if(eval("\x01") == 46)
  104.       {
  105.          set("\x01",eval("\x01") + 233);
  106.          loop4:
  107.          while(true)
  108.          {
  109.             set(┬º┬ºpop(),eval(┬º┬ºpop()) + 530);
  110.             while(true)
  111.             {
  112.                if(eval("\x01") == 440)
  113.                {
  114.                   set("\x01",eval("\x01") - 134);
  115.                   ┬º┬ºpush(true);
  116.                   continue;
  117.                }
  118.                if(eval("\x01") == 88)
  119.                {
  120.                   set("\x01",eval("\x01") + 645);
  121.                   break loop0;
  122.                }
  123.                if(eval("\x01") == 87)
  124.                {
  125.                   set("\x01",eval("\x01") + 790);
  126.                   if(┬º┬ºpop())
  127.                   {
  128.                      set("\x01",eval("\x01") - 585);
  129.                   }
  130.                   continue;
  131.                }
  132.                if(eval("\x01") == 767)
  133.                {
  134.                   set("\x01",eval("\x01") + 7);
  135.                   continue;
  136.                }
  137.                if(eval("\x01") == 726)
  138.                {
  139.                   set("\x01",eval("\x01") - 140);
  140.                   continue;
  141.                }
  142.                if(eval("\x01") == 664)
  143.                {
  144.                   set("\x01",eval("\x01") + 8);
  145.                   if(┬º┬ºpop())
  146.                   {
  147.                      set("\x01",eval("\x01") + 107);
  148.                   }
  149.                   continue;
  150.                }
  151.                if(eval("\x01") == 630)
  152.                {
  153.                   set("\x01",eval("\x01") - 47);
  154.                   continue;
  155.                }
  156.                if(eval("\x01") == 549)
  157.                {
  158.                   set("\x01",eval("\x01") + 408);
  159.                   break loop0;
  160.                }
  161.                if(eval("\x01") == 11)
  162.                {
  163.                   set("\x01",eval("\x01") + 663);
  164.                   continue;
  165.                }
  166.                if(eval("\x01") == 774)
  167.                {
  168.                   set("\x01",eval("\x01") - 687);
  169.                   ┬º┬ºpush(true);
  170.                   continue;
  171.                }
  172.                if(eval("\x01") == 733)
  173.                {
  174.                   set("\x01",eval("\x01") + 41);
  175.                   continue;
  176.                }
  177.                if(eval("\x01") == 704)
  178.                {
  179.                   set("\x01",eval("\x01") - 391);
  180.                   continue;
  181.                }
  182.                if(eval("\x01") == 779)
  183.                {
  184.                   set("\x01",eval("\x01") - 105);
  185.                   continue;
  186.                }
  187.                if(eval("\x01") == 672)
  188.                {
  189.                   set("\x01",eval("\x01") + 107);
  190.                   loop19:
  191.                   while(true)
  192.                   {
  193.                      set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  194.                      addr1980:
  195.                      while(true)
  196.                      {
  197.                         if(eval("\x01") == 968)
  198.                         {
  199.                            set("\x01",eval("\x01") - 959);
  200.                            ┬º┬ºpush(true);
  201.                            continue;
  202.                         }
  203.                         if(eval("\x01") == 288)
  204.                         {
  205.                            set("\x01",eval("\x01") - 191);
  206.                            break loop0;
  207.                         }
  208.                         if(eval("\x01") == 776)
  209.                         {
  210.                            set("\x01",eval("\x01") - 606);
  211.                            ┬º┬ºpush(true);
  212.                            continue;
  213.                         }
  214.                         if(eval("\x01") == 196)
  215.                         {
  216.                            set("\x01",eval("\x01") - 95);
  217.                            if(┬º┬ºpop())
  218.                            {
  219.                               set("\x01",eval("\x01") + 51);
  220.                            }
  221.                            continue;
  222.                         }
  223.                         if(eval("\x01") == 898)
  224.                         {
  225.                            set("\x01",eval("\x01") - 593);
  226.                            ┬º┬ºpush(true);
  227.                            continue;
  228.                         }
  229.                         if(eval("\x01") == 84)
  230.                         {
  231.                            set("\x01",eval("\x01") + 692);
  232.                            continue;
  233.                         }
  234.                         if(eval("\x01") == 557)
  235.                         {
  236.                            set("\x01",eval("\x01") - 361);
  237.                            ┬º┬ºpush(true);
  238.                            continue;
  239.                         }
  240.                         if(eval("\x01") == 761)
  241.                         {
  242.                            set("\x01",eval("\x01") + 137);
  243.                            continue;
  244.                         }
  245.                         if(eval("\x01") == 157)
  246.                         {
  247.                            set("\x01",eval("\x01") - 64);
  248.                            ┬º┬ºpush(true);
  249.                            continue;
  250.                         }
  251.                         if(eval("\x01") != 101)
  252.                         {
  253.                            if(eval("\x01") == 839)
  254.                            {
  255.                               set("\x01",eval("\x01") - 805);
  256.                               ┬º┬ºpush(true);
  257.                            }
  258.                            else
  259.                            {
  260.                               if(eval("\x01") == 415)
  261.                               {
  262.                                  set("\x01",eval("\x01") - 399);
  263.                                  break loop0;
  264.                               }
  265.                               if(eval("\x01") == 305)
  266.                               {
  267.                                  set("\x01",eval("\x01") + 110);
  268.                                  if(┬º┬ºpop())
  269.                                  {
  270.                                     set("\x01",eval("\x01") - 399);
  271.                                  }
  272.                               }
  273.                               else if(eval("\x01") == 656)
  274.                               {
  275.                                  set("\x01",eval("\x01") + 162);
  276.                               }
  277.                               else if(eval("\x01") == 9)
  278.                               {
  279.                                  set("\x01",eval("\x01") + 800);
  280.                                  if(┬º┬ºpop())
  281.                                  {
  282.                                     set("\x01",eval("\x01") - 153);
  283.                                  }
  284.                               }
  285.                               else
  286.                               {
  287.                                  if(eval("\x01") == 809)
  288.                                  {
  289.                                     set("\x01",eval("\x01") - 153);
  290.                                     prevFrame();
  291.                                     break loop0;
  292.                                  }
  293.                                  if(eval("\x01") == 58)
  294.                                  {
  295.                                     set("\x01",eval("\x01") + 248);
  296.                                  }
  297.                                  else if(eval("\x01") == 681)
  298.                                  {
  299.                                     set("\x01",eval("\x01") + 137);
  300.                                  }
  301.                                  else if(eval("\x01") == 202)
  302.                                  {
  303.                                     set("\x01",eval("\x01") - 45);
  304.                                  }
  305.                                  else if(eval("\x01") == 110)
  306.                                  {
  307.                                     set("\x01",eval("\x01") + 178);
  308.                                     if(┬º┬ºpop())
  309.                                     {
  310.                                        set("\x01",eval("\x01") - 191);
  311.                                     }
  312.                                  }
  313.                                  else if(eval("\x01") == 248)
  314.                                  {
  315.                                     set("\x01",eval("\x01") + 591);
  316.                                  }
  317.                                  else if(eval("\x01") == 920)
  318.                                  {
  319.                                     set("\x01",eval("\x01") - 611);
  320.                                  }
  321.                                  else
  322.                                  {
  323.                                     if(eval("\x01") == 989)
  324.                                     {
  325.                                        set("\x01",eval("\x01") - 4);
  326.                                        set(┬º┬ºpop(),eval("\x01") + 170);
  327.                                        break loop0;
  328.                                     }
  329.                                     if(eval("\x01") == 683)
  330.                                     {
  331.                                        set("\x01",eval("\x01") - 543);
  332.                                        if(┬º┬ºpop())
  333.                                        {
  334.                                           set("\x01",eval("\x01") - 56);
  335.                                        }
  336.                                     }
  337.                                     else
  338.                                     {
  339.                                        if(eval("\x01") == 140)
  340.                                        {
  341.                                           set("\x01",eval("\x01") - 56);
  342.                                           stopAllSounds();
  343.                                           break loop0;
  344.                                        }
  345.                                        if(eval("\x01") == 275)
  346.                                        {
  347.                                           set("\x01",eval("\x01") + 501);
  348.                                        }
  349.                                        else
  350.                                        {
  351.                                           if(eval("\x01") == 21)
  352.                                           {
  353.                                              set("\x01",eval("\x01") + 227);
  354.                                              prevFrame();
  355.                                              ┬º┬ºpush(┬º┬ºpop() eq ┬º┬ºpop());
  356.                                              break loop0;
  357.                                           }
  358.                                           if(eval("\x01") == 609)
  359.                                           {
  360.                                              set("\x01",eval("\x01") - 452);
  361.                                           }
  362.                                           else if(eval("\x01") == 132)
  363.                                           {
  364.                                              set("\x01",eval("\x01") + 810);
  365.                                              if(┬º┬ºpop())
  366.                                              {
  367.                                                 set("\x01",eval("\x01") - 26);
  368.                                              }
  369.                                           }
  370.                                           else
  371.                                           {
  372.                                              if(eval("\x01") == 942)
  373.                                              {
  374.                                                 set("\x01",eval("\x01") - 26);
  375.                                                 break loop0;
  376.                                              }
  377.                                              if(eval("\x01") == 233)
  378.                                              {
  379.                                                 set("\x01",eval("\x01") - 212);
  380.                                                 if(┬º┬ºpop())
  381.                                                 {
  382.                                                    set("\x01",eval("\x01") + 227);
  383.                                                 }
  384.                                              }
  385.                                              else
  386.                                              {
  387.                                                 if(eval("\x01") == 688)
  388.                                                 {
  389.                                                    set("\x01",eval("\x01") + 73);
  390.                                                    break loop0;
  391.                                                 }
  392.                                                 if(eval("\x01") == 497)
  393.                                                 {
  394.                                                    set("\x01",eval("\x01") + 342);
  395.                                                 }
  396.                                                 else if(eval("\x01") == 985)
  397.                                                 {
  398.                                                    set("\x01",eval("\x01") - 428);
  399.                                                 }
  400.                                                 else if(eval("\x01") == 20)
  401.                                                 {
  402.                                                    set("\x01",eval("\x01") + 213);
  403.                                                    ┬º┬ºpush(true);
  404.                                                 }
  405.                                                 else if(eval("\x01") == 306)
  406.                                                 {
  407.                                                    set("\x01",eval("\x01") + 377);
  408.                                                    ┬º┬ºpush(true);
  409.                                                 }
  410.                                                 else if(eval("\x01") == 16)
  411.                                                 {
  412.                                                    set("\x01",eval("\x01") + 293);
  413.                                                 }
  414.                                                 else if(eval("\x01") == 235)
  415.                                                 {
  416.                                                    set("\x01",eval("\x01") - 125);
  417.                                                    ┬º┬ºpush(true);
  418.                                                 }
  419.                                                 else if(eval("\x01") == 93)
  420.                                                 {
  421.                                                    set("\x01",eval("\x01") + 896);
  422.                                                    if(┬º┬ºpop())
  423.                                                    {
  424.                                                       set("\x01",eval("\x01") - 4);
  425.                                                    }
  426.                                                 }
  427.                                                 else if(eval("\x01") == 475)
  428.                                                 {
  429.                                                    set("\x01",eval("\x01") - 455);
  430.                                                 }
  431.                                                 else if(eval("\x01") == 416)
  432.                                                 {
  433.                                                    set("\x01",eval("\x01") + 482);
  434.                                                 }
  435.                                                 else
  436.                                                 {
  437.                                                    if(eval("\x01") == 34)
  438.                                                    {
  439.                                                       break;
  440.                                                    }
  441.                                                    if(eval("\x01") == 608)
  442.                                                    {
  443.                                                       set("\x01",eval("\x01") + 1);
  444.                                                       break loop0;
  445.                                                    }
  446.                                                    if(eval("\x01") == 860)
  447.                                                    {
  448.                                                       set("\x01",eval("\x01") - 303);
  449.                                                    }
  450.                                                    else if(eval("\x01") == 818)
  451.                                                    {
  452.                                                       set("\x01",eval("\x01") - 686);
  453.                                                       ┬º┬ºpush(true);
  454.                                                    }
  455.                                                    else if(eval("\x01") == 916)
  456.                                                    {
  457.                                                       set("\x01",eval("\x01") - 681);
  458.                                                    }
  459.                                                    else
  460.                                                    {
  461.                                                       if(eval("\x01") == 152)
  462.                                                       {
  463.                                                          ┬º┬ºpush("\x01");
  464.                                                          ┬º┬ºpush(eval("\x01"));
  465.                                                          ┬º┬ºpush(154);
  466.                                                          continue loop19;
  467.                                                       }
  468.                                                       if(eval("\x01") == 170)
  469.                                                       {
  470.                                                          set("\x01",eval("\x01") + 518);
  471.                                                          if(┬º┬ºpop())
  472.                                                          {
  473.                                                             set("\x01",eval("\x01") + 73);
  474.                                                          }
  475.                                                       }
  476.                                                       else if(eval("\x01") == 215)
  477.                                                       {
  478.                                                          set("\x01",eval("\x01") + 20);
  479.                                                       }
  480.                                                       else
  481.                                                       {
  482.                                                          if(eval("\x01") == 309)
  483.                                                          {
  484.                                                             set("\x01",eval("\x01") + 558);
  485.                                                             stop();
  486.                                                             break loop0;
  487.                                                          }
  488.                                                          if(eval("\x01") != 97)
  489.                                                          {
  490.                                                             if(eval("\x01") == 867)
  491.                                                             {
  492.                                                                set("\x01",eval("\x01") - 867);
  493.                                                             }
  494.                                                             break loop0;
  495.                                                          }
  496.                                                          set("\x01",eval("\x01") - 77);
  497.                                                       }
  498.                                                    }
  499.                                                 }
  500.                                              }
  501.                                           }
  502.                                        }
  503.                                     }
  504.                                  }
  505.                               }
  506.                            }
  507.                            continue;
  508.                         }
  509.                         set("\x01",eval("\x01") + 51);
  510.                         while(true)
  511.                         {
  512.                            if(┬º┬ºpop())
  513.                            {
  514.                               set("\x01",eval("\x01") + 327);
  515.                               if(┬º┬ºpop())
  516.                               {
  517.                                  set("\x01",eval("\x01") + 336);
  518.                               }
  519.                               continue;
  520.                            }
  521.                            if(eval("\x01") == 627)
  522.                            {
  523.                               set("\x01",eval("\x01") + 144);
  524.                               continue;
  525.                            }
  526.                            if(eval("\x01") == 449)
  527.                            {
  528.                               set("\x01",eval("\x01") + 20);
  529.                               toggleHighQuality();
  530.                               break loop0;
  531.                            }
  532.                            if(eval("\x01") == 940)
  533.                            {
  534.                               set("\x01",eval("\x01") - 319);
  535.                               continue;
  536.                            }
  537.                            if(eval("\x01") == 953)
  538.                            {
  539.                               set("\x01",eval("\x01") - 182);
  540.                               continue;
  541.                            }
  542.                            if(eval("\x01") == 13)
  543.                            {
  544.                               set("\x01",eval("\x01") - 9);
  545.                               ┬º┬ºpush(true);
  546.                               continue;
  547.                            }
  548.                            if(eval("\x01") == 473)
  549.                            {
  550.                               set("\x01",eval("\x01") - 141);
  551.                               prevFrame();
  552.                               break loop0;
  553.                            }
  554.                            if(eval("\x01") == 872)
  555.                            {
  556.                               set("\x01",eval("\x01") - 527);
  557.                               if(┬º┬ºpop())
  558.                               {
  559.                                  set("\x01",eval("\x01") - 224);
  560.                               }
  561.                               continue;
  562.                            }
  563.                            if(eval("\x01") == 471)
  564.                            {
  565.                               set("\x01",eval("\x01") - 80);
  566.                               continue;
  567.                            }
  568.                            if(eval("\x01") == 617)
  569.                            {
  570.                               set("\x01",eval("\x01") + 336);
  571.                               break loop0;
  572.                            }
  573.                            if(eval("\x01") == 390)
  574.                            {
  575.                               set("\x01",eval("\x01") - 377);
  576.                               continue;
  577.                            }
  578.                            if(eval("\x01") != 836)
  579.                            {
  580.                               if(eval("\x01") == 203)
  581.                               {
  582.                                  set("\x01",eval("\x01") + 633);
  583.                                  if(┬º┬ºpop())
  584.                                  {
  585.                                     set("\x01",eval("\x01") - 397);
  586.                                  }
  587.                               }
  588.                               else if(eval("\x01") == 771)
  589.                               {
  590.                                  set("\x01",eval("\x01") - 222);
  591.                                  ┬º┬ºpush(true);
  592.                               }
  593.                               else if(eval("\x01") == 621)
  594.                               {
  595.                                  set("\x01",eval("\x01") + 251);
  596.                                  ┬º┬ºpush(true);
  597.                               }
  598.                               else if(eval("\x01") == 476)
  599.                               {
  600.                                  set("\x01",eval("\x01") + 117);
  601.                                  ┬º┬ºpush(true);
  602.                               }
  603.                               else if(eval("\x01") == 391)
  604.                               {
  605.                                  set("\x01",eval("\x01") - 188);
  606.                                  ┬º┬ºpush(true);
  607.                               }
  608.                               else if(eval("\x01") == 838)
  609.                               {
  610.                                  set("\x01",eval("\x01") + 41);
  611.                               }
  612.                               else if(eval("\x01") == 926)
  613.                               {
  614.                                  set("\x01",eval("\x01") - 535);
  615.                               }
  616.                               else if(eval("\x01") == 439)
  617.                               {
  618.                                  set("\x01",eval("\x01") + 182);
  619.                               }
  620.                               else if(eval("\x01") == 39)
  621.                               {
  622.                                  set("\x01",eval("\x01") + 437);
  623.                               }
  624.                               else
  625.                               {
  626.                                  if(eval("\x01") == 832)
  627.                                  {
  628.                                     set("\x01",eval("\x01") + 144);
  629.                                     ┬º{invalid_utf8=191}>{invalid_utf8=153}W\\{invalid_utf8=229}┬º--;
  630.                                     if(eval("{invalid_utf8=191}>{invalid_utf8=153}W\\{invalid_utf8=229}") == 0)
  631.                                     {
  632.                                        gotoAndStop(1);
  633.                                     }
  634.                                     else
  635.                                     {
  636.                                        gotoAndStop("Loop");
  637.                                        play();
  638.                                     }
  639.                                     break loop0;
  640.                                  }
  641.                                  if(eval("\x01") == 549)
  642.                                  {
  643.                                     set("\x01",eval("\x01") + 436);
  644.                                     if(┬º┬ºpop())
  645.                                     {
  646.                                        set("\x01",eval("\x01") - 543);
  647.                                     }
  648.                                  }
  649.                                  else if(eval("\x01") == 4)
  650.                                  {
  651.                                     set("\x01",eval("\x01") + 469);
  652.                                     if(┬º┬ºpop())
  653.                                     {
  654.                                        set("\x01",eval("\x01") - 141);
  655.                                     }
  656.                                  }
  657.                                  else if(eval("\x01") == 469)
  658.                                  {
  659.                                     set("\x01",eval("\x01") - 456);
  660.                                  }
  661.                                  else
  662.                                  {
  663.                                     if(eval("\x01") == 41)
  664.                                     {
  665.                                        set("\x01",eval("\x01") + 885);
  666.                                        loop11:
  667.                                        while(true)
  668.                                        {
  669.                                           set(┬º┬ºpop(),eval(┬º┬ºpop()) - 353);
  670.                                           while(true)
  671.                                           {
  672.                                              if(eval("\x01") == 214)
  673.                                              {
  674.                                                 set("\x01",eval("\x01") + 182);
  675.                                                 ┬º┬ºpush(true);
  676.                                              }
  677.                                              else if(eval("\x01") == 476)
  678.                                              {
  679.                                                 set("\x01",eval("\x01") - 243);
  680.                                                 if(┬º┬ºpop())
  681.                                                 {
  682.                                                    set("\x01",eval("\x01") + 651);
  683.                                                 }
  684.                                              }
  685.                                              else if(eval("\x01") == 84)
  686.                                              {
  687.                                                 set("\x01",eval("\x01") + 392);
  688.                                                 ┬º┬ºpush(true);
  689.                                              }
  690.                                              else if(eval("\x01") == 0)
  691.                                              {
  692.                                                 set("\x01",eval("\x01") + 508);
  693.                                              }
  694.                                              else if(eval("\x01") == 647)
  695.                                              {
  696.                                                 set("\x01",eval("\x01") - 563);
  697.                                              }
  698.                                              else if(eval("\x01") == 396)
  699.                                              {
  700.                                                 set("\x01",eval("\x01") + 455);
  701.                                                 if(┬º┬ºpop())
  702.                                                 {
  703.                                                    set("\x01",eval("\x01") - 851);
  704.                                                 }
  705.                                              }
  706.                                              else
  707.                                              {
  708.                                                 if(eval("\x01") == 437)
  709.                                                 {
  710.                                                    break;
  711.                                                 }
  712.                                                 if(eval("\x01") == 233)
  713.                                                 {
  714.                                                    set("\x01",eval("\x01") + 651);
  715.                                                    break loop0;
  716.                                                 }
  717.                                                 if(eval("\x01") == 802)
  718.                                                 {
  719.                                                    break loop11;
  720.                                                 }
  721.                                                 if(eval("\x01") == 884)
  722.                                                 {
  723.                                                    set("\x01",eval("\x01") - 292);
  724.                                                 }
  725.                                                 else if(eval("\x01") == 237)
  726.                                                 {
  727.                                                    set("\x01",eval("\x01") + 355);
  728.                                                 }
  729.                                                 else
  730.                                                 {
  731.                                                    if(eval("\x01") == 851)
  732.                                                    {
  733.                                                       set("\x01",eval("\x01") - 851);
  734.                                                       break loop0;
  735.                                                    }
  736.                                                    if(eval("\x01") == 93)
  737.                                                    {
  738.                                                       set("\x01",eval("\x01") + 415);
  739.                                                    }
  740.                                                    else if(eval("\x01") == 488)
  741.                                                    {
  742.                                                       set("\x01",eval("\x01") - 130);
  743.                                                    }
  744.                                                    else if(eval("\x01") == 508)
  745.                                                    {
  746.                                                       set("\x01",eval("\x01") + 32);
  747.                                                       ┬º┬ºpush(true);
  748.                                                    }
  749.                                                    else if(eval("\x01") == 540)
  750.                                                    {
  751.                                                       set("\x01",eval("\x01") + 262);
  752.                                                       if(┬º┬ºpop())
  753.                                                       {
  754.                                                          set("\x01",eval("\x01") - 365);
  755.                                                       }
  756.                                                    }
  757.                                                    else if(eval("\x01") == 592)
  758.                                                    {
  759.                                                       set("\x01",eval("\x01") - 568);
  760.                                                       ┬º┬ºpush(true);
  761.                                                    }
  762.                                                    else if(eval("\x01") == 24)
  763.                                                    {
  764.                                                       set("\x01",eval("\x01") + 147);
  765.                                                       if(┬º┬ºpop())
  766.                                                       {
  767.                                                          set("\x01",eval("\x01") + 572);
  768.                                                       }
  769.                                                    }
  770.                                                    else
  771.                                                    {
  772.                                                       if(eval("\x01") == 171)
  773.                                                       {
  774.                                                          set("\x01",eval("\x01") + 572);
  775.                                                          break loop0;
  776.                                                       }
  777.                                                       if(eval("\x01") != 743)
  778.                                                       {
  779.                                                          if(eval("\x01") == 358)
  780.                                                          {
  781.                                                             set("\x01",eval("\x01") - 55);
  782.                                                             myStatus = "stunned";
  783.                                                             var count = _root.opponentStunTime;
  784.                                                             gotoAndStop("Loop");
  785.                                                             play();
  786.                                                             break loop0;
  787.                                                          }
  788.                                                          if(eval("\x01") == 303)
  789.                                                          {
  790.                                                             set("\x01",eval("\x01") - 303);
  791.                                                          }
  792.                                                          break loop0;
  793.                                                       }
  794.                                                       set("\x01",eval("\x01") - 385);
  795.                                                    }
  796.                                                 }
  797.                                              }
  798.                                           }
  799.                                        }
  800.                                        set("\x01",eval("\x01") - 365);
  801.                                        break loop0;
  802.                                     }
  803.                                     if(eval("\x01") == 985)
  804.                                     {
  805.                                        set("\x01",eval("\x01") - 543);
  806.                                        break loop0;
  807.                                     }
  808.                                     if(eval("\x01") == 345)
  809.                                     {
  810.                                        set("\x01",eval("\x01") - 224);
  811.                                        break loop0;
  812.                                     }
  813.                                     if(eval("\x01") == 332)
  814.                                     {
  815.                                        set("\x01",eval("\x01") + 408);
  816.                                     }
  817.                                     else if(eval("\x01") == 738)
  818.                                     {
  819.                                        set("\x01",eval("\x01") - 697);
  820.                                        if(┬º┬ºpop())
  821.                                        {
  822.                                           set("\x01",eval("\x01") + 885);
  823.                                        }
  824.                                     }
  825.                                     else if(eval("\x01") == 879)
  826.                                     {
  827.                                        set("\x01",eval("\x01") - 47);
  828.                                     }
  829.                                     else if(eval("\x01") == 740)
  830.                                     {
  831.                                        set("\x01",eval("\x01") - 2);
  832.                                        ┬º┬ºpush(true);
  833.                                     }
  834.                                     else if(eval("\x01") == 121)
  835.                                     {
  836.                                        set("\x01",eval("\x01") + 758);
  837.                                     }
  838.                                     else if(eval("\x01") == 140)
  839.                                     {
  840.                                        set("\x01",eval("\x01") + 600);
  841.                                     }
  842.                                     else if(eval("\x01") == 442)
  843.                                     {
  844.                                        set("\x01",eval("\x01") + 34);
  845.                                     }
  846.                                     else
  847.                                     {
  848.                                        if(eval("\x01") != 593)
  849.                                        {
  850.                                           if(eval("\x01") == 976)
  851.                                           {
  852.                                              set("\x01",eval("\x01") - 976);
  853.                                           }
  854.                                           break loop0;
  855.                                        }
  856.                                        set("\x01",eval("\x01") - 144);
  857.                                        if(┬º┬ºpop())
  858.                                        {
  859.                                           set("\x01",eval("\x01") + 20);
  860.                                        }
  861.                                     }
  862.                                  }
  863.                               }
  864.                               continue;
  865.                            }
  866.                            set("\x01",eval("\x01") - 397);
  867.                            loop13:
  868.                            while(true)
  869.                            {
  870.                               set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  871.                               ┬º┬ºpush(true);
  872.                               while(eval("\x01") != 804)
  873.                               {
  874.                                  if(eval("\x01") == 508)
  875.                                  {
  876.                                     set("\x01",eval("\x01") - 56);
  877.                                     if(┬º┬ºpop())
  878.                                     {
  879.                                        set("\x01",eval("\x01") - 64);
  880.                                     }
  881.                                     continue;
  882.                                  }
  883.                                  if(eval("\x01") == 852)
  884.                                  {
  885.                                     set("\x01",eval("\x01") - 41);
  886.                                     continue;
  887.                                  }
  888.                                  if(eval("\x01") == 277)
  889.                                  {
  890.                                     set("\x01",eval("\x01") + 456);
  891.                                     stop();
  892.                                     break loop0;
  893.                                  }
  894.                                  if(eval("\x01") == 216)
  895.                                  {
  896.                                     break loop13;
  897.                                  }
  898.                                  if(eval("\x01") != 452)
  899.                                  {
  900.                                     if(eval("\x01") == 355)
  901.                                     {
  902.                                        set("\x01",eval("\x01") - 78);
  903.                                     }
  904.                                     else if(eval("\x01") == 160)
  905.                                     {
  906.                                        set("\x01",eval("\x01") + 117);
  907.                                     }
  908.                                     else if(eval("\x01") == 388)
  909.                                     {
  910.                                        set("\x01",eval("\x01") + 423);
  911.                                     }
  912.                                     else if(eval("\x01") == 811)
  913.                                     {
  914.                                        set("\x01",eval("\x01") - 119);
  915.                                        ┬º┬ºpush(true);
  916.                                     }
  917.                                     else
  918.                                     {
  919.                                        if(eval("\x01") != 692)
  920.                                        {
  921.                                           if(eval("\x01") == 733)
  922.                                           {
  923.                                              set("\x01",eval("\x01") - 733);
  924.                                           }
  925.                                           break loop0;
  926.                                        }
  927.                                        set("\x01",eval("\x01") - 476);
  928.                                        if(┬º┬ºpop())
  929.                                        {
  930.                                           set("\x01",eval("\x01") - 56);
  931.                                        }
  932.                                     }
  933.                                     continue;
  934.                                  }
  935.                                  set("\x01",eval("\x01") - 64);
  936.                                  loop15:
  937.                                  while(true)
  938.                                  {
  939.                                     if(┬º┬ºpop())
  940.                                     {
  941.                                        set("\x01",eval("\x01") + 108);
  942.                                     }
  943.                                     else if(eval("\x01") == 277)
  944.                                     {
  945.                                        set("\x01",eval("\x01") - 222);
  946.                                        if(┬º┬ºpop())
  947.                                        {
  948.                                           set("\x01",eval("\x01") + 879);
  949.                                        }
  950.                                     }
  951.                                     else
  952.                                     {
  953.                                        if(eval("\x01") == 55)
  954.                                        {
  955.                                           set("\x01",eval("\x01") + 879);
  956.                                           break loop0;
  957.                                        }
  958.                                        if(eval("\x01") == 342)
  959.                                        {
  960.                                           set("\x01",eval("\x01") + 412);
  961.                                           if(┬º┬ºpop())
  962.                                           {
  963.                                              set("\x01",eval("\x01") - 498);
  964.                                           }
  965.                                        }
  966.                                        else if(eval("\x01") == 264)
  967.                                        {
  968.                                           set("\x01",eval("\x01") + 26);
  969.                                        }
  970.                                        else if(eval("\x01") == 994)
  971.                                        {
  972.                                           set("\x01",eval("\x01") - 652);
  973.                                           ┬º┬ºpush(true);
  974.                                        }
  975.                                        else if(eval("\x01") == 256)
  976.                                        {
  977.                                           set("\x01",eval("\x01") + 722);
  978.                                        }
  979.                                        else
  980.                                        {
  981.                                           if(eval("\x01") == 290)
  982.                                           {
  983.                                              set("\x01",eval("\x01") + 425);
  984.                                              stop();
  985.                                              break loop0;
  986.                                           }
  987.                                           if(eval("\x01") == 754)
  988.                                           {
  989.                                              set("\x01",eval("\x01") - 498);
  990.                                              break loop0;
  991.                                           }
  992.                                           if(eval("\x01") != 896)
  993.                                           {
  994.                                              if(eval("\x01") == 715)
  995.                                              {
  996.                                                 set("\x01",eval("\x01") - 715);
  997.                                              }
  998.                                              break loop0;
  999.                                           }
  1000.                                           set("\x01",eval("\x01") + 98);
  1001.                                        }
  1002.                                     }
  1003.                                     while(true)
  1004.                                     {
  1005.                                        if(eval("\x01") == 758)
  1006.                                        {
  1007.                                           set("\x01",eval("\x01") - 481);
  1008.                                           ┬º┬ºpush(true);
  1009.                                           continue;
  1010.                                        }
  1011.                                        if(eval("\x01") == 978)
  1012.                                        {
  1013.                                           set("\x01",eval("\x01") - 892);
  1014.                                           ┬º┬ºpush(true);
  1015.                                           continue;
  1016.                                        }
  1017.                                        if(eval("\x01") == 730)
  1018.                                        {
  1019.                                           set("\x01",eval("\x01") + 248);
  1020.                                           continue;
  1021.                                        }
  1022.                                        if(eval("\x01") == 574)
  1023.                                        {
  1024.                                           break;
  1025.                                        }
  1026.                                        if(eval("\x01") == 934)
  1027.                                        {
  1028.                                           set("\x01",eval("\x01") + 60);
  1029.                                           continue;
  1030.                                        }
  1031.                                        if(eval("\x01") == 86)
  1032.                                        {
  1033.                                           set("\x01",eval("\x01") + 488);
  1034.                                           if(┬º┬ºpop())
  1035.                                           {
  1036.                                              set("\x01",eval("\x01") - 392);
  1037.                                           }
  1038.                                           continue;
  1039.                                        }
  1040.                                        continue loop15;
  1041.                                     }
  1042.                                     set("\x01",eval("\x01") - 392);
  1043.                                     break loop0;
  1044.                                  }
  1045.                               }
  1046.                            }
  1047.                            set("\x01",eval("\x01") - 56);
  1048.                            loop17:
  1049.                            while(true)
  1050.                            {
  1051.                               if(┬º┬ºpop())
  1052.                               {
  1053.                                  set("\x01",eval("\x01") - 104);
  1054.                                  ┬º┬ºpush(true);
  1055.                               }
  1056.                               else if(eval("\x01") == 12)
  1057.                               {
  1058.                                  set("\x01",eval("\x01") + 900);
  1059.                                  if(┬º┬ºpop())
  1060.                                  {
  1061.                                     set("\x01",eval("\x01") - 48);
  1062.                                  }
  1063.                               }
  1064.                               else if(eval("\x01") == 126)
  1065.                               {
  1066.                                  set("\x01",eval("\x01") + 600);
  1067.                                  ┬º┬ºpush(true);
  1068.                               }
  1069.                               else if(eval("\x01") == 604)
  1070.                               {
  1071.                                  set("\x01",eval("\x01") - 143);
  1072.                                  ┬º┬ºpush(true);
  1073.                               }
  1074.                               else if(eval("\x01") == 660)
  1075.                               {
  1076.                                  set("\x01",eval("\x01") - 56);
  1077.                               }
  1078.                               else if(eval("\x01") == 911)
  1079.                               {
  1080.                                  set("\x01",eval("\x01") - 758);
  1081.                                  ┬º┬ºpush(true);
  1082.                               }
  1083.                               else if(eval("\x01") == 726)
  1084.                               {
  1085.                                  set("\x01",eval("\x01") - 547);
  1086.                                  if(┬º┬ºpop())
  1087.                                  {
  1088.                                     set("\x01",eval("\x01") - 37);
  1089.                                  }
  1090.                               }
  1091.                               else if(eval("\x01") == 142)
  1092.                               {
  1093.                                  set("\x01",eval("\x01") + 750);
  1094.                               }
  1095.                               else
  1096.                               {
  1097.                                  if(eval("\x01") != 461)
  1098.                                  {
  1099.                                     if(eval("\x01") == 179)
  1100.                                     {
  1101.                                        set("\x01",eval("\x01") - 37);
  1102.                                        prevFrame();
  1103.                                        break loop0;
  1104.                                     }
  1105.                                     if(eval("\x01") == 568)
  1106.                                     {
  1107.                                        set("\x01",eval("\x01") + 42);
  1108.                                        break loop0;
  1109.                                     }
  1110.                                     if(eval("\x01") == 242)
  1111.                                     {
  1112.                                        set("\x01",eval("\x01") - 242);
  1113.                                     }
  1114.                                     break loop0;
  1115.                                  }
  1116.                                  set("\x01",eval("\x01") - 356);
  1117.                                  if(┬º┬ºpop())
  1118.                                  {
  1119.                                     set("\x01",eval("\x01") - 5);
  1120.                                  }
  1121.                               }
  1122.                               while(true)
  1123.                               {
  1124.                                  if(eval("\x01") == 559)
  1125.                                  {
  1126.                                     set("\x01",eval("\x01") - 547);
  1127.                                     ┬º┬ºpush(true);
  1128.                                     continue;
  1129.                                  }
  1130.                                  if(eval("\x01") == 18)
  1131.                                  {
  1132.                                     set("\x01",eval("\x01") + 642);
  1133.                                     break loop0;
  1134.                                  }
  1135.                                  if(eval("\x01") == 912)
  1136.                                  {
  1137.                                     set("\x01",eval("\x01") - 48);
  1138.                                     break loop0;
  1139.                                  }
  1140.                                  if(eval("\x01") == 780)
  1141.                                  {
  1142.                                     set("\x01",eval("\x01") - 762);
  1143.                                     if(┬º┬ºpop())
  1144.                                     {
  1145.                                        set("\x01",eval("\x01") + 642);
  1146.                                     }
  1147.                                     continue;
  1148.                                  }
  1149.                                  if(eval("\x01") == 105)
  1150.                                  {
  1151.                                     set("\x01",eval("\x01") - 5);
  1152.                                     break loop0;
  1153.                                  }
  1154.                                  if(eval("\x01") == 100)
  1155.                                  {
  1156.                                     set("\x01",eval("\x01") - 86);
  1157.                                     continue;
  1158.                                  }
  1159.                                  if(eval("\x01") == 833)
  1160.                                  {
  1161.                                     set("\x01",eval("\x01") + 59);
  1162.                                     continue;
  1163.                                  }
  1164.                                  if(eval("\x01") == 656)
  1165.                                  {
  1166.                                     set("\x01",eval("\x01") - 52);
  1167.                                     continue;
  1168.                                  }
  1169.                                  if(eval("\x01") == 564)
  1170.                                  {
  1171.                                     set("\x01",eval("\x01") + 362);
  1172.                                     if(┬º┬ºpop())
  1173.                                     {
  1174.                                        set("\x01",eval("\x01") - 460);
  1175.                                     }
  1176.                                     continue;
  1177.                                  }
  1178.                                  if(eval("\x01") == 745)
  1179.                                  {
  1180.                                     set("\x01",eval("\x01") + 166);
  1181.                                     continue;
  1182.                                  }
  1183.                                  if(eval("\x01") == 206)
  1184.                                  {
  1185.                                     set("\x01",eval("\x01") - 80);
  1186.                                     continue;
  1187.                                  }
  1188.                                  if(eval("\x01") == 153)
  1189.                                  {
  1190.                                     set("\x01",eval("\x01") + 415);
  1191.                                     if(┬º┬ºpop())
  1192.                                     {
  1193.                                        set("\x01",eval("\x01") + 42);
  1194.                                     }
  1195.                                     continue;
  1196.                                  }
  1197.                                  if(eval("\x01") == 590)
  1198.                                  {
  1199.                                     set("\x01",eval("\x01") - 406);
  1200.                                     continue;
  1201.                                  }
  1202.                                  if(eval("\x01") == 509)
  1203.                                  {
  1204.                                     set("\x01",eval("\x01") - 383);
  1205.                                     continue;
  1206.                                  }
  1207.                                  if(eval("\x01") == 610)
  1208.                                  {
  1209.                                     set("\x01",eval("\x01") - 426);
  1210.                                     continue;
  1211.                                  }
  1212.                                  if(eval("\x01") == 892)
  1213.                                  {
  1214.                                     set("\x01",eval("\x01") - 328);
  1215.                                     ┬º┬ºpush(true);
  1216.                                     continue;
  1217.                                  }
  1218.                                  if(eval("\x01") == 539)
  1219.                                  {
  1220.                                     set("\x01",eval("\x01") + 345);
  1221.                                     continue;
  1222.                                  }
  1223.                                  if(eval("\x01") == 22)
  1224.                                  {
  1225.                                     set("\x01",eval("\x01") + 487);
  1226.                                     break loop0;
  1227.                                  }
  1228.                                  if(eval("\x01") == 33)
  1229.                                  {
  1230.                                     set("\x01",eval("\x01") - 11);
  1231.                                     if(┬º┬ºpop())
  1232.                                     {
  1233.                                        set("\x01",eval("\x01") + 487);
  1234.                                     }
  1235.                                     continue;
  1236.                                  }
  1237.                                  if(eval("\x01") == 926)
  1238.                                  {
  1239.                                     set("\x01",eval("\x01") - 460);
  1240.                                     break loop0;
  1241.                                  }
  1242.                                  if(eval("\x01") == 466)
  1243.                                  {
  1244.                                     set("\x01",eval("\x01") + 445);
  1245.                                     continue;
  1246.                                  }
  1247.                                  if(eval("\x01") == 864)
  1248.                                  {
  1249.                                     set("\x01",eval("\x01") + 20);
  1250.                                     continue;
  1251.                                  }
  1252.                                  if(eval("\x01") == 14)
  1253.                                  {
  1254.                                     set("\x01",eval("\x01") + 19);
  1255.                                     ┬º┬ºpush(true);
  1256.                                     continue;
  1257.                                  }
  1258.                                  if(eval("\x01") == 215)
  1259.                                  {
  1260.                                     set("\x01",eval("\x01") - 201);
  1261.                                     continue;
  1262.                                  }
  1263.                                  if(eval("\x01") == 184)
  1264.                                  {
  1265.                                     set("\x01",eval("\x01") + 58);
  1266.                                     myStatus = "normal";
  1267.                                     stop();
  1268.                                     break loop0;
  1269.                                  }
  1270.                                  continue loop17;
  1271.                               }
  1272.                            }
  1273.                         }
  1274.                      }
  1275.                      set("\x01",eval("\x01") + 574);
  1276.                      if(!┬º┬ºpop())
  1277.                      {
  1278.                         while(true)
  1279.                         {
  1280.                            ┬º┬ºgoto(addr1980);
  1281.                         }
  1282.                         ┬º┬ºgoto(addr2119);
  1283.                         addr2623:
  1284.                      }
  1285.                      addr2617:
  1286.                      ┬º┬ºpush("\x01");
  1287.                      ┬º┬ºpush(eval("\x01") + 1);
  1288.                   }
  1289.                }
  1290.                else
  1291.                {
  1292.                   if(eval("\x01") == 617)
  1293.                   {
  1294.                      set("\x01",eval("\x01") + 234);
  1295.                      continue;
  1296.                   }
  1297.                   if(eval("\x01") == 583)
  1298.                   {
  1299.                      set("\x01",eval("\x01") + 109);
  1300.                      ┬º┬ºpush(true);
  1301.                      continue;
  1302.                   }
  1303.                   if(eval("\x01") == 279)
  1304.                   {
  1305.                      set("\x01",eval("\x01") + 34);
  1306.                      continue;
  1307.                   }
  1308.                   if(eval("\x01") != 395)
  1309.                   {
  1310.                      if(eval("\x01") == 692)
  1311.                      {
  1312.                         set("\x01",eval("\x01") - 420);
  1313.                         if(┬º┬ºpop())
  1314.                         {
  1315.                            set("\x01",eval("\x01") + 7);
  1316.                         }
  1317.                      }
  1318.                      else
  1319.                      {
  1320.                         if(eval("\x01") == 272)
  1321.                         {
  1322.                            set("\x01",eval("\x01") + 7);
  1323.                            gotoAndStop("\x1b");
  1324.                            break loop0;
  1325.                         }
  1326.                         if(eval("\x01") == 300)
  1327.                         {
  1328.                            set("\x01",eval("\x01") + 426);
  1329.                            break loop0;
  1330.                         }
  1331.                         if(eval("\x01") == 313)
  1332.                         {
  1333.                            set("\x01",eval("\x01") + 351);
  1334.                            ┬º┬ºpush(true);
  1335.                         }
  1336.                         else if(eval("\x01") == 674)
  1337.                         {
  1338.                            set("\x01",eval("\x01") + 155);
  1339.                            ┬º┬ºpush(true);
  1340.                         }
  1341.                         else
  1342.                         {
  1343.                            if(eval("\x01") == 877)
  1344.                            {
  1345.                               set("\x01",eval("\x01") - 585);
  1346.                               break loop0;
  1347.                            }
  1348.                            if(eval("\x01") == 956)
  1349.                            {
  1350.                               set("\x01",eval("\x01") - 868);
  1351.                               if(┬º┬ºpop())
  1352.                               {
  1353.                                  set("\x01",eval("\x01") + 645);
  1354.                               }
  1355.                            }
  1356.                            else if(eval("\x01") == 586)
  1357.                            {
  1358.                               set("\x01",eval("\x01") + 214);
  1359.                               ┬º┬ºpush(true);
  1360.                            }
  1361.                            else if(eval("\x01") == 851)
  1362.                            {
  1363.                               set("\x01",eval("\x01") + 105);
  1364.                               ┬º┬ºpush(true);
  1365.                            }
  1366.                            else if(eval("\x01") == 829)
  1367.                            {
  1368.                               set("\x01",eval("\x01") - 189);
  1369.                               if(┬º┬ºpop())
  1370.                               {
  1371.                                  set("\x01",eval("\x01") - 272);
  1372.                               }
  1373.                            }
  1374.                            else if(eval("\x01") == 292)
  1375.                            {
  1376.                               set("\x01",eval("\x01") + 291);
  1377.                            }
  1378.                            else
  1379.                            {
  1380.                               if(eval("\x01") == 321)
  1381.                               {
  1382.                                  break;
  1383.                               }
  1384.                               if(eval("\x01") == 640)
  1385.                               {
  1386.                                  set("\x01",eval("\x01") - 272);
  1387.                                  break loop0;
  1388.                               }
  1389.                               if(eval("\x01") == 368)
  1390.                               {
  1391.                                  set("\x01",eval("\x01") + 226);
  1392.                               }
  1393.                               else if(eval("\x01") == 339)
  1394.                               {
  1395.                                  set("\x01",eval("\x01") + 210);
  1396.                                  if(┬º┬ºpop())
  1397.                                  {
  1398.                                     set("\x01",eval("\x01") + 408);
  1399.                                  }
  1400.                               }
  1401.                               else if(eval("\x01") == 67)
  1402.                               {
  1403.                                  set("\x01",eval("\x01") + 527);
  1404.                               }
  1405.                               else if(eval("\x01") == 957)
  1406.                               {
  1407.                                  set("\x01",eval("\x01") - 254);
  1408.                               }
  1409.                               else if(eval("\x01") == 594)
  1410.                               {
  1411.                                  set("\x01",eval("\x01") - 255);
  1412.                                  ┬º┬ºpush(true);
  1413.                               }
  1414.                               else if(eval("\x01") == 758)
  1415.                               {
  1416.                                  set("\x01",eval("\x01") - 55);
  1417.                               }
  1418.                               else if(eval("\x01") == 130)
  1419.                               {
  1420.                                  set("\x01",eval("\x01") + 456);
  1421.                               }
  1422.                               else if(eval("\x01") == 800)
  1423.                               {
  1424.                                  set("\x01",eval("\x01") - 405);
  1425.                                  if(┬º┬ºpop())
  1426.                                  {
  1427.                                     set("\x01",eval("\x01") + 222);
  1428.                                  }
  1429.                               }
  1430.                               else if(eval("\x01") == 703)
  1431.                               {
  1432.                                  set("\x01",eval("\x01") + 69);
  1433.                               }
  1434.                               else
  1435.                               {
  1436.                                  if(eval("\x01") == 772)
  1437.                                  {
  1438.                                     break loop4;
  1439.                                  }
  1440.                                  if(eval("\x01") == 611)
  1441.                                  {
  1442.                                     set("\x01",eval("\x01") - 611);
  1443.                                     break loop0;
  1444.                                  }
  1445.                                  if(eval("\x01") != 306)
  1446.                                  {
  1447.                                     break loop0;
  1448.                                  }
  1449.                                  set("\x01",eval("\x01") - 6);
  1450.                                  if(┬º┬ºpop())
  1451.                                  {
  1452.                                     set("\x01",eval("\x01") + 426);
  1453.                                  }
  1454.                               }
  1455.                            }
  1456.                         }
  1457.                      }
  1458.                      continue;
  1459.                   }
  1460.                   set("\x01",eval("\x01") + 222);
  1461.                }
  1462.                while(true)
  1463.                {
  1464.                   set(┬º┬ºpop(),┬º┬ºpop());
  1465.                   ┬º┬ºgoto(addr2623);
  1466.                   ┬º┬ºgoto(addr2617);
  1467.                }
  1468.             }
  1469.          }
  1470.          set("\x01",eval("\x01") - 161);
  1471.          ┬º{invalid_utf8=192}\x17\x12\x11\x0f{invalid_utf8=157}┬º--;
  1472.          if(eval("{invalid_utf8=192}\x17\x12\x11\x0f{invalid_utf8=157}") == 0)
  1473.          {
  1474.             gotoAndStop(1);
  1475.          }
  1476.          else
  1477.          {
  1478.             gotoAndStop("Loop");
  1479.             play();
  1480.          }
  1481.          break;
  1482.       }
  1483.       if(eval("\x01") == 223)
  1484.       {
  1485.          set("\x01",eval("\x01") + 392);
  1486.          break;
  1487.       }
  1488.       if(eval("\x01") == 210)
  1489.       {
  1490.          set("\x01",eval("\x01") + 121);
  1491.          ┬º┬ºpush(true);
  1492.          continue;
  1493.       }
  1494.       if(eval("\x01") == 331)
  1495.       {
  1496.          set("\x01",eval("\x01") - 285);
  1497.          if(┬º┬ºpop())
  1498.          {
  1499.             set("\x01",eval("\x01") + 233);
  1500.          }
  1501.          continue;
  1502.       }
  1503.       if(eval("\x01") != 932)
  1504.       {
  1505.          if(eval("\x01") == 399)
  1506.          {
  1507.             set("\x01",eval("\x01") - 189);
  1508.          }
  1509.          else if(eval("\x01") == 606)
  1510.          {
  1511.             set("\x01",eval("\x01") - 419);
  1512.          }
  1513.          else if(eval("\x01") == 267)
  1514.          {
  1515.             set("\x01",eval("\x01") + 187);
  1516.             ┬º┬ºpush(true);
  1517.          }
  1518.          else if(eval("\x01") == 961)
  1519.          {
  1520.             set("\x01",eval("\x01") - 244);
  1521.          }
  1522.          else if(eval("\x01") == 991)
  1523.          {
  1524.             set("\x01",eval("\x01") - 498);
  1525.          }
  1526.          else if(eval("\x01") == 309)
  1527.          {
  1528.             set("\x01",eval("\x01") + 404);
  1529.             ┬º┬ºpush(true);
  1530.          }
  1531.          else if(eval("\x01") == 19)
  1532.          {
  1533.             set("\x01",eval("\x01") + 290);
  1534.          }
  1535.          else if(eval("\x01") == 841)
  1536.          {
  1537.             set("\x01",eval("\x01") - 654);
  1538.          }
  1539.          else if(eval("\x01") == 615)
  1540.          {
  1541.             set("\x01",eval("\x01") - 348);
  1542.          }
  1543.          else if(eval("\x01") == 858)
  1544.          {
  1545.             set("\x01",eval("\x01") - 591);
  1546.          }
  1547.          else
  1548.          {
  1549.             if(eval("\x01") == 275)
  1550.             {
  1551.                set("\x01",eval("\x01") + 716);
  1552.                setProperty(┬º┬ºpop(), _X, ┬º┬ºpop() + ┬º┬ºpop());
  1553.                ┬º┬ºpush(┬º┬ºpop() >>> (┬º┬ºpop() instanceof ┬º┬ºpop() >>> ┬º┬ºpop()));
  1554.                break;
  1555.             }
  1556.             if(eval("\x01") == 215)
  1557.             {
  1558.                set("\x01",eval("\x01") + 278);
  1559.             }
  1560.             else
  1561.             {
  1562.                if(eval("\x01") == 760)
  1563.                {
  1564.                   set("\x01",eval("\x01") + 81);
  1565.                   ┬º┬ºpush(mbsubstring(┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop()));
  1566.                   break;
  1567.                }
  1568.                if(eval("\x01") == 187)
  1569.                {
  1570.                   set("\x01",eval("\x01") + 737);
  1571.                   ┬º┬ºpush(true);
  1572.                }
  1573.                else
  1574.                {
  1575.                   if(eval("\x01") == 277)
  1576.                   {
  1577.                      set("\x01",eval("\x01") - 105);
  1578.                      break;
  1579.                   }
  1580.                   if(eval("\x01") != 172)
  1581.                   {
  1582.                      if(eval("\x01") == 493)
  1583.                      {
  1584.                         set("\x01",eval("\x01") + 51);
  1585.                         play();
  1586.                         break;
  1587.                      }
  1588.                      if(eval("\x01") == 544)
  1589.                      {
  1590.                         set("\x01",eval("\x01") - 544);
  1591.                      }
  1592.                      break;
  1593.                   }
  1594.                   set("\x01",eval("\x01") + 38);
  1595.                }
  1596.             }
  1597.          }
  1598.          continue;
  1599.       }
  1600.       set("\x01",eval("\x01") - 914);
  1601.       loop1:
  1602.       while(true)
  1603.       {
  1604.          set(┬º┬ºpop(),┬º┬ºpop() + 820);
  1605.          loop2:
  1606.          while(true)
  1607.          {
  1608.             while(true)
  1609.             {
  1610.                if(eval("\x01") == 989)
  1611.                {
  1612.                   set("\x01",eval("\x01") - 965);
  1613.                   ┬º┬ºpush(true);
  1614.                }
  1615.                else if(eval("\x01") == 103)
  1616.                {
  1617.                   set("\x01",eval("\x01") + 317);
  1618.                }
  1619.                else if(eval("\x01") == 178)
  1620.                {
  1621.                   set("\x01",eval("\x01") + 793);
  1622.                }
  1623.                else
  1624.                {
  1625.                   if(eval("\x01") == 24)
  1626.                   {
  1627.                      break;
  1628.                   }
  1629.                   if(eval("\x01") == 870)
  1630.                   {
  1631.                      set("\x01",eval("\x01") - 570);
  1632.                   }
  1633.                   else if(eval("\x01") == 648)
  1634.                   {
  1635.                      set("\x01",eval("\x01") + 168);
  1636.                      if(┬º┬ºpop())
  1637.                      {
  1638.                         set("\x01",eval("\x01") - 670);
  1639.                      }
  1640.                   }
  1641.                   else if(eval("\x01") == 984)
  1642.                   {
  1643.                      set("\x01",eval("\x01") - 909);
  1644.                      if(┬º┬ºpop())
  1645.                      {
  1646.                         set("\x01",eval("\x01") + 131);
  1647.                      }
  1648.                   }
  1649.                   else if(eval("\x01") == 868)
  1650.                   {
  1651.                      set("\x01",eval("\x01") - 220);
  1652.                      ┬º┬ºpush(true);
  1653.                   }
  1654.                   else if(eval("\x01") == 659)
  1655.                   {
  1656.                      set("\x01",eval("\x01") - 52);
  1657.                      if(┬º┬ºpop())
  1658.                      {
  1659.                         set("\x01",eval("\x01") - 429);
  1660.                      }
  1661.                   }
  1662.                   else if(eval("\x01") == 300)
  1663.                   {
  1664.                      set("\x01",eval("\x01") + 684);
  1665.                      ┬º┬ºpush(true);
  1666.                   }
  1667.                   else if(eval("\x01") == 664)
  1668.                   {
  1669.                      set("\x01",eval("\x01") - 5);
  1670.                      ┬º┬ºpush(true);
  1671.                   }
  1672.                   else if(eval("\x01") == 97)
  1673.                   {
  1674.                      set("\x01",eval("\x01") + 874);
  1675.                   }
  1676.                   else
  1677.                   {
  1678.                      if(eval("\x01") == 75)
  1679.                      {
  1680.                         set("\x01",eval("\x01") + 131);
  1681.                         break loop0;
  1682.                      }
  1683.                      if(eval("\x01") == 189)
  1684.                      {
  1685.                         set("\x01",eval("\x01") + 111);
  1686.                      }
  1687.                      else
  1688.                      {
  1689.                         if(eval("\x01") == 816)
  1690.                         {
  1691.                            break loop2;
  1692.                         }
  1693.                         if(eval("\x01") == 206)
  1694.                         {
  1695.                            set("\x01",eval("\x01") + 214);
  1696.                         }
  1697.                         else
  1698.                         {
  1699.                            if(eval("\x01") == 607)
  1700.                            {
  1701.                               set("\x01",eval("\x01") - 429);
  1702.                               break loop0;
  1703.                            }
  1704.                            if(eval("\x01") == 72)
  1705.                            {
  1706.                               set("\x01",eval("\x01") + 798);
  1707.                               break loop0;
  1708.                            }
  1709.                            if(eval("\x01") == 955)
  1710.                            {
  1711.                               set("\x01",eval("\x01") - 291);
  1712.                            }
  1713.                            else
  1714.                            {
  1715.                               if(eval("\x01") == 420)
  1716.                               {
  1717.                                  set("\x01",eval("\x01") + 63);
  1718.                                  stop();
  1719.                                  break loop0;
  1720.                               }
  1721.                               if(eval("\x01") == 770)
  1722.                               {
  1723.                                  set("\x01",eval("\x01") - 698);
  1724.                                  if(┬º┬ºpop())
  1725.                                  {
  1726.                                     set("\x01",eval("\x01") + 798);
  1727.                                  }
  1728.                               }
  1729.                               else
  1730.                               {
  1731.                                  if(eval("\x01") == 483)
  1732.                                  {
  1733.                                     set("\x01",eval("\x01") - 483);
  1734.                                     break loop0;
  1735.                                  }
  1736.                                  if(eval("\x01") == 883)
  1737.                                  {
  1738.                                     set("\x01",eval("\x01") - 219);
  1739.                                  }
  1740.                                  else if(eval("\x01") == 938)
  1741.                                  {
  1742.                                     set("\x01",eval("\x01") - 168);
  1743.                                     ┬º┬ºpush(true);
  1744.                                  }
  1745.                                  else
  1746.                                  {
  1747.                                     if(eval("\x01") == 63)
  1748.                                     {
  1749.                                        set("\x01",eval("\x01") + 820);
  1750.                                        break loop0;
  1751.                                     }
  1752.                                     if(eval("\x01") == 96)
  1753.                                     {
  1754.                                        set("\x01",eval("\x01") + 842);
  1755.                                     }
  1756.                                     else if(eval("\x01") == 146)
  1757.                                     {
  1758.                                        set("\x01",eval("\x01") + 792);
  1759.                                     }
  1760.                                     else if(eval("\x01") == 412)
  1761.                                     {
  1762.                                        set("\x01",eval("\x01") + 456);
  1763.                                     }
  1764.                                     else if(eval("\x01") == 971)
  1765.                                     {
  1766.                                        set("\x01",eval("\x01") - 262);
  1767.                                        ┬º┬ºpush(true);
  1768.                                     }
  1769.                                     else if(eval("\x01") == 769)
  1770.                                     {
  1771.                                        set("\x01",eval("\x01") + 99);
  1772.                                     }
  1773.                                     else
  1774.                                     {
  1775.                                        if(eval("\x01") != 709)
  1776.                                        {
  1777.                                           if(eval("\x01") == 330)
  1778.                                           {
  1779.                                              set("\x01",eval("\x01") + 439);
  1780.                                           }
  1781.                                           break loop0;
  1782.                                        }
  1783.                                        set("\x01",eval("\x01") - 379);
  1784.                                        if(┬º┬ºpop())
  1785.                                        {
  1786.                                           set("\x01",eval("\x01") + 439);
  1787.                                        }
  1788.                                     }
  1789.                                  }
  1790.                               }
  1791.                            }
  1792.                         }
  1793.                      }
  1794.                   }
  1795.                }
  1796.             }
  1797.             set("\x01",eval("\x01") + 39);
  1798.             if(!┬º┬ºpop())
  1799.             {
  1800.                continue;
  1801.             }
  1802.             continue loop1;
  1803.          }
  1804.          set("\x01",eval("\x01") - 670);
  1805.          break loop0;
  1806.       }
  1807.    }
  1808. }
  1809.